#include "Zdarzenia.h"
#include <string>
#include <iostream>
#include <vector>
#include <math.h>
 using namespace std;
/*
uzupelnic te funkcje, ale pytanie czy nie lepiej byloby to w gui dac i jedna klase mniej tworzyc??
*/
Zdarzenia::Zdarzenia()
{
		id=1;
	//przydalyby sie funkcje karbosa zeby przez siec zaladowac dane
	Connector::getInstance();
	Connector::getInstance()->createListener("EVENTS");
	
	lotniska=pobierz_liste_lotnisk();
	samoloty=pobierz_liste_samolotow();
	zdarzenia=pobierz_liste_zdarzen();
	
}

Zdarzenia::~Zdarzenia()
	{
	}

int Zdarzenia::wylicz_zasieg()
	{
	return 0;
	}

char * Zdarzenia::wybor_maszyny()
{
    int i=rand()%4;
	if(i==0)
    	    return "xeon";
	if(i==1)
	    return "nec";
	if(i==2)
	    return "yoyek";
	else
	    return "siodmy";

}

void Zdarzenia::czy_wyladowal(int id_sam, string nazwa_lotniska)
{
    
    vector<samolot_polozenie>::iterator ptr;
    
    for(ptr=akt_pol_samolotow.begin();ptr!=akt_pol_samolotow.end();ptr++)
	{
	    if(ptr->id_samolotu==id_sam)
		break;
	}
    
    if(nazwa_lotniska==ptr->lotnisko_docelowe)
    {
	    ptr->lotnisko_zrodlowe=ptr->lotnisko_docelowe;
	    ptr->wyladowal=true;
    }
    else if(nazwa_lotniska!="null")
    {
    	    ptr->lotnisko_zrodlowe=nazwa_lotniska;
	    ptr->wyladowal=true;
    }
    else
	akt_pol_samolotow.erase(ptr);
    
}

void Zdarzenia::wyslij_samolot()
	{
		string lotnisko_start=airport_from;
		string lotnisko_doc=airport_to;
		string nazwa_sam=airplane;
		
		if((lotnisko_start=="null")||(lotnisko_doc=="null")||(nazwa_sam=="null"))
		    return;

				cout<<"lotnisko startowe: "<<lotnisko_start<<endl;
				cout<<"lotnisko docelowe: "<<lotnisko_doc<<endl;
				cout<<"nazwa samolotu: "<<nazwa_sam<<endl;
				cout<<"nadano id		:	"<<id<<endl;
		int id_start=0;
		int id_doc=0;
		int id_samolotu=id;
		string pomocny;
		vector<lotnisko>::iterator wsk;

	for(wsk=lotniska.begin(); wsk!=lotniska.end(); wsk++)
			{
				pomocny=wsk->nazwa;
				if(lotnisko_start==pomocny)
					{
						id_start=wsk->id_lotniska;
					}
				else if(lotnisko_doc==pomocny)
					{
						id_doc=wsk->id_lotniska;
					}
			}

		samolot_polozenie nowy;
		nowy.id_samolotu=id_samolotu;
		nowy.nazwa_samolotu=nazwa_sam;
		nowy.lotnisko_zrodlowe=lotnisko_start;
		nowy.lotnisko_docelowe=lotnisko_doc;
		nowy.wyladowal=false;

		akt_pol_samolotow.push_back(nowy);

		powolaj_samolot("xeon",id_start, id_doc, id_samolotu, nazwa_sam);

		id++;
}

void Zdarzenia::wyslij_ponownie_samolot()
{

		string lotnisko_start=airport_from;
		string lotnisko_doc=airport_to;
		string nazwa_sam=airplane;
		
		if((lotnisko_start=="null")||(lotnisko_doc=="null")||(nazwa_sam=="null"))
		    return;

				cout<<"lotnisko startowe: "<<lotnisko_start<<endl;
				cout<<"lotnisko docelowe: "<<lotnisko_doc<<endl;
				cout<<"nazwa samolotu: "<<nazwa_sam<<endl;
				cout<<"nadano id		:	"<<id<<endl;
		int id_start=0;
		int id_doc=0;
		int id_samolotu=airplane_id;
		string pomocny;
		vector<lotnisko>::iterator wsk;

	for(wsk=lotniska.begin(); wsk!=lotniska.end(); wsk++)
			{
				pomocny=wsk->nazwa;
				if(lotnisko_start==pomocny)
					{
						id_start=wsk->id_lotniska;
					}
				else if(lotnisko_doc==pomocny)
					{
						id_doc=wsk->id_lotniska;
					}
			}

		
		vector<samolot_polozenie>::iterator ptr;
		
		for(ptr=akt_pol_samolotow.begin();ptr!=akt_pol_samolotow.end();ptr++)
		    {
			if(ptr->id_samolotu==id_samolotu)
			    {
			     ptr->lotnisko_zrodlowe=lotnisko_start;
			     ptr->lotnisko_docelowe=lotnisko_doc;
			     ptr->wyladowal=false;
			    }
		    
		    }
		

		powolaj_samolot("xeon",id_start, id_doc, id_samolotu, nazwa_sam);
		
}


double Zdarzenia::wylicz_zasieg(int id_lotniska_start, int id_lotniska_doc)
	{
		float wsp_dl_start=0;
		float wsp_szer_start=0;
		float wsp_dl_doc=0;
		float wsp_szer_doc=0;

		vector<lotnisko>::iterator wsk;

		//wyszukanie odpowiednich danych z lotnis



		for(wsk=lotniska.begin(); wsk!=lotniska.end(); wsk++)
			{
				if(id_lotniska_start==wsk->id_lotniska)
					{
						cout<<"startowe"<<endl;
						wsp_dl_start=wsk->dlugosc_geo;
						wsp_szer_start=wsk->szerokosc_geo;
					}
				else if(id_lotniska_doc==wsk->id_lotniska)
					{
						cout<<"docelowe"<<endl;
						wsp_dl_doc=wsk->dlugosc_geo;
						wsp_szer_doc=wsk->szerokosc_geo;
					}
			}



		//obliczenie odleglosci miedzy nimi

		float pomoc1=0;
		float pomoc2=0;
		float pomoc3=0;

		pomoc1=((wsp_dl_doc - wsp_dl_start) * cos(wsp_szer_start/57.29746936)*111120);
		pomoc2=((wsp_szer_doc - wsp_szer_start)*111120);

		pomoc3=sqrt((pow(pomoc1,2.0)+pow(pomoc2,2.0))/1000);

	return pomoc3;

	}

vector<lotnisko> Zdarzenia::lotniska_w_zasiegu()
{
	string airport = airport_from;
	string plane = airplane;

	vector<lotnisko>::iterator ptr;
	vector<lotnisko>::iterator ptr1;
	vector<lotnisko> nowy;

	vector<samolot>::iterator wsk;
	cout<<lotniska.size()<<endl;

	for(ptr1=lotniska.begin();ptr1!=lotniska.end();ptr1++)
		{
			if(ptr1->nazwa==airport)
			  break;
		}

	for(wsk=samoloty.begin();wsk!=samoloty.end();wsk++)
		{
			cout<<"wybor ssamolotu"<<endl;
			if(wsk->nazwa==plane)
			  break;
		}

	for(ptr=lotniska.begin(); ptr!=lotniska.end(); ptr++)
		{
			if(((wsk->bak)/(wsk->spalanie)<wylicz_zasieg(ptr1->id_lotniska,ptr->id_lotniska))&&(ptr->nazwa!=airport) )
				{
				nowy.push_back(*ptr);
				}
		}

	return nowy;
}

bool Zdarzenia::sprawdz_stan(int id_samolot)					//sprawdzamy stan samolotu
	{
		bool polozenie=false;
		vector<samolot_polozenie>::iterator wsk;

		//wyszukanie odpowiednich danych z lotnisk

		for(wsk=akt_pol_samolotow.begin(); wsk!=akt_pol_samolotow.end(); wsk++)
			{
				if(id_samolot==wsk->id_samolotu)
					{
				polozenie = wsk->wyladowal;
					}
			}

		return polozenie;

	}

void Zdarzenia::dodaj_awarie_samolotu()
	{
		string nazwa_awarii =  airplane_event;
		
		if(nazwa_awarii=="null")
		    return;
		cout << "w zdarzeniach"<< endl;
		zdarzenie pomocnik;

		vector<zdarzenie>::iterator ptr;

			for(ptr=zdarzenia.begin() ;ptr!=zdarzenia.end() ;ptr++ )
				{
					if(ptr->nazwa==nazwa_awarii)
					{
					 pomocnik.typ=ptr->typ;
					 pomocnik.nazwa=ptr->nazwa;
					 pomocnik.podtyp=ptr->podtyp;
					 break;
					}
				}



		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		int flag=0;
			for(wsk=awarie_samolotow.begin() ;wsk!=awarie_samolotow.end() ;wsk++ )
				{
					if(wsk->id_obiektu==airplane_id)
					{
					 (wsk->awaria).push_back(pomocnik);
					 flag++;
					 break;
					}

				}

			//gdyby samolotu nie bylo jeszcze na liscie awaryjnych

			if(flag==0)
				{	//najgorsza akcja gdy samolot nie ma zadnej awarii
					lista_awarii nowy;
					nowy.id_obiektu=airplane_id; // to na teraz taka blokada
					nowy.nazwa_obiektu="null";
					nowy.awaria.push_back(pomocnik);
					awarie_samolotow.push_back(nowy);
				}
		cout<<"dodalem awarie"<<pomocnik.nazwa<<endl;
		cout << awarie_samolotow.begin()->id_obiektu<<endl;
		char k[20];
		wywolaj_awarie_samolotu(airplane_id ,nazwa_awarii ,itoa(pomocnik.podtyp,k,10), level);
	}

//================================================================

vector<zdarzenie> Zdarzenia::mozliwe_awarie_samolot()
{
		vector<zdarzenie>::iterator ptr;
		vector<zdarzenie>::iterator ptr1;
		vector<lista_awarii>::iterator wsk;

		vector<zdarzenie> nowy;

	for(wsk=awarie_samolotow.begin(); wsk!=awarie_samolotow.end(); wsk++)
		{
		cout<<wsk->nazwa_obiektu<<endl;
		if(wsk->id_obiektu==airplane_id)
		    break;
		}

	if(wsk!=NULL && wsk!=awarie_samolotow.end() && (wsk->awaria).begin()!=NULL)
		for(ptr1=zdarzenia.begin(); ptr1!=zdarzenia.end(); ptr1++)
		{
			for(ptr=(wsk->awaria).begin(); ptr!=(wsk->awaria).end(); ptr++)
			{
					if((ptr->nazwa==ptr1->nazwa))
						break;
			}


			if((ptr==(wsk->awaria).end())&&ptr1->typ==1)
			{
					 nowy.push_back(*ptr1);
			}
		}

	else
	{
	     for(ptr1=zdarzenia.begin();ptr1!=zdarzenia.end();ptr1++)
	     {
	      if(ptr1->typ==1)
	         nowy.push_back(*ptr1);
	     }
	}
	return nowy;
}

void Zdarzenia::usun_awarie_samolotu()
	{

		string nazwa_awarii =  airplane_event;
		
		if(nazwa_awarii=="null")
		    return;
		
		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		vector<zdarzenie>::iterator ptr;

			for(wsk=awarie_samolotow.begin() ;wsk!=awarie_samolotow.end() ;wsk++ )
				{
					if(wsk->id_obiektu==airplane_id)
					{

						for(ptr=(wsk->awaria).begin();ptr!=(wsk->awaria).end();ptr++)
							{
								if(ptr->nazwa==nazwa_awarii)
									{
										(wsk->awaria).erase(ptr);
								
									break;
									}
							}
					 break;
					}

				}

	zakoncz_awarie_samolotu(airplane_id, nazwa_awarii);

	}

//===============================================================
	void Zdarzenia::aktualizacja_polozenia(int id_samolot, bool stan)	//aktualizacja polozenia: ziemia/powietrze
	{

		vector<samolot_polozenie>::iterator wsk;

		//wyszukanie odpowiednich danych z lotnisk

		for(wsk=akt_pol_samolotow.begin(); wsk!=akt_pol_samolotow.end(); wsk++)
			{
				if(id_samolot==wsk->id_samolotu)
					{
					wsk->wyladowal=stan;
					if(stan==true)
						  {
							wsk->lotnisko_zrodlowe=wsk->lotnisko_docelowe;
							wsk->lotnisko_docelowe="null";
						}
					}
			}


	}
//===============================================================
	vector<samolot_polozenie> Zdarzenia::get_polozenie()			//zwraca liste polozenia samolotow
	{
		return akt_pol_samolotow;
	}
//===============================================================
	vector<samolot> Zdarzenia::get_samoloty()						//zwraca dostepne samoloty
	{

		return samoloty;

	}
//===============================================================
	vector<lista_awarii> Zdarzenia::get_samoloty_awarie()			//zwraca liste samolotow i ich awarii
	{

	 	return awarie_samolotow;

	}
//===============================================================
	lista_awarii Zdarzenia::get_samolot_awarie(const char* nazwa_samolot)
	{

		lista_awarii konkretny;
		vector<lista_awarii>::iterator wsk;

		for(wsk=awarie_samolotow.begin(); wsk!=awarie_samolotow.end(); wsk++)
			{
				if(airplane_id==wsk->id_obiektu)
					{
					konkretny=(*wsk);
					}
			}
		return konkretny;
	}


vector<samolot_polozenie> Zdarzenia::get_aktywne_samoloty()
	{
		vector<samolot_polozenie>::iterator ptr;
		vector<samolot_polozenie> nowy;

		for(ptr=akt_pol_samolotow.begin(); ptr!=akt_pol_samolotow.end(); ptr++)
			{
			    
				if(ptr->wyladowal==false)
				{ nowy.push_back(*ptr);
				  ptr->id_samolotu;}
			}

		return nowy;
	}


//LOTNISKO

	void Zdarzenia::dodaj_awarie_lotniska()
	{
		string nazwa_awarii =  airport_event;
		string nazwa_lotniska = airport_from;
		
		if((nazwa_awarii=="null")||(nazwa_lotniska=="null"))
		    return;
		
		cout << "dodalem awarie lotniska:"<<endl<<"lotnisko: "<<nazwa_lotniska<<endl<<"awaria: "<<nazwa_awarii<<endl;	
		zdarzenie pomocnik;
		
		vector<zdarzenie>::iterator ptr;
		
			for(ptr=zdarzenia.begin() ;ptr!=zdarzenia.end() ;ptr++ )
				{
					if(ptr->nazwa==nazwa_awarii)
					{
					 pomocnik.typ=ptr->typ;
					 pomocnik.nazwa=ptr->nazwa;
					 pomocnik.podtyp=ptr->podtyp;
					 break;
					}	
				}	
		
		
		
		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		int flag=0;
		
			for(wsk=awarie_lotnisk.begin() ;wsk!=awarie_lotnisk.end() ;wsk++ )
				{
					if(wsk->nazwa_obiektu==nazwa_lotniska)
					{
					 (wsk->awaria).push_back(pomocnik);
					 flag++;
					 break;
					}
				
				}

			//gdyby samolotu nie bylo jeszcze na liscie awaryjnych

			if(flag==0)
				{	//najgorsza akcja gdy samolot nie ma zadnej awarii
					lista_awarii nowy;
					nowy.id_obiektu=0; // to na teraz taka blokada
					nowy.nazwa_obiektu=nazwa_lotniska;
					nowy.awaria.push_back(pomocnik);
					awarie_lotnisk.push_back(nowy);

				}	
				char k[10];
				wywolaj_awarie_lotniska(nazwa_lotniska, nazwa_awarii,itoa(pomocnik.podtyp,k,10),level);
}

//==============================================================	
	void Zdarzenia::dodaj_awarie_pogody()
	{
	
		string nazwa_awarii =  weather;
		string nazwa_lotniska = airport_from; //
		
		if((nazwa_awarii=="null")||(nazwa_lotniska=="null"))
		    return;
		
		cout << "dodalem awarie pogody:"<<endl<<"lotnisko: "<<nazwa_lotniska<<endl<<"pogoda: "<<nazwa_awarii<<endl;
		cout << "dlugosc" << nazwa_awarii.size()<<endl;
		zdarzenie pomocnik;
		
		vector<zdarzenie>::iterator ptr;
		
			for(ptr=zdarzenia.begin() ;ptr!=zdarzenia.end() ;ptr++ )
				{
					if(ptr->nazwa==nazwa_awarii)
					{
					 pomocnik.typ=ptr->typ;
					 pomocnik.nazwa=ptr->nazwa;
					 pomocnik.podtyp=ptr->podtyp;
					 break;
					}	
				}	
		
		
		
		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		int flag=0;
		
			for(wsk=stan_pogody.begin() ;wsk!=stan_pogody.end() ;wsk++ )
				{
					if(wsk->nazwa_obiektu==nazwa_lotniska)
					{
					 (wsk->awaria).push_back(pomocnik);
					 flag++;
					 break;
					}
				
				}

			//gdyby samolotu nie bylo jeszcze na liscie awaryjnych

			if(flag==0)
				{	//najgorsza akcja gdy samolot nie ma zadnej awarii
					lista_awarii nowy;
					nowy.id_obiektu=0; // to na teraz taka blokada
					nowy.nazwa_obiektu=nazwa_lotniska;
					nowy.awaria.push_back(pomocnik);
					stan_pogody.push_back(nowy);
				}	
		char k[20];
		wywolaj_awarie_lotniska(nazwa_lotniska, nazwa_awarii,itoa(pomocnik.podtyp,k,10),level);
	
	}

//===============================================================	
void Zdarzenia::usun_awarie_lotniska()
	{
	
		string nazwa_awarii =  airport_event;
		string nazwa_lotniska = airport_from;
		
		if((nazwa_awarii=="null")||(nazwa_lotniska=="null"))
		    return;
		    
cout << "usuwam awarie lotniska:"<<endl<<"lotnisko: "<<nazwa_lotniska<<endl<<"awaria: "<<nazwa_awarii<<endl;		
		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		vector<zdarzenie>::iterator ptr;
		
			for(wsk=awarie_lotnisk.begin() ;wsk!=awarie_lotnisk.end() ;wsk++ )
				{ 
					if(!strncmp((wsk->nazwa_obiektu).c_str(),(nazwa_lotniska).c_str(),(wsk->nazwa_obiektu).size()))
					{
						cout<<"znalazlem lotnisko"<<endl;
						for(ptr=(wsk->awaria).begin();ptr!=(wsk->awaria).end();ptr++)
							{    
								cout<<ptr->nazwa<<": "<<nazwa_awarii<<endl;
		
								if(ptr->nazwa==nazwa_awarii)
									{
										(wsk->awaria).erase(ptr);
								
										cout<<"line"<<endl;
										
									break;
									}
								
							}			 
					 break;
					}
				
				}//bylo nazwa_lotniska
				zakoncz_awarie_lotniska(wsk->nazwa_obiektu, nazwa_awarii);

	}
//==============================================================	

//==============================================================	
void Zdarzenia::usun_awarie_pogody()
	{
	
		string nazwa_awarii =  weather;
		string nazwa_lotniska = airport_from; 
cout << "usuwam awarie pogody:"<<endl<<"lotnisko: "<<nazwa_lotniska<<endl<<"pogoda: "<<nazwa_awarii<<endl;		
		vector<lista_awarii>::iterator wsk;  //warto by to w pryszlosci zamienic
		vector<zdarzenie>::iterator ptr;
		
			for(wsk=stan_pogody.begin() ;wsk!=stan_pogody.end() ;wsk++ )
				{
					if(!strncmp((wsk->nazwa_obiektu).c_str(),(nazwa_lotniska).c_str(),(wsk->nazwa_obiektu).size()) )
					{
						
						for(ptr=(wsk->awaria).begin();ptr!=(wsk->awaria).end();ptr++)
							{
								if(ptr->nazwa==nazwa_awarii)
									{
										(wsk->awaria).erase(ptr);
									
									break;
									}
							}			 
					 break;
					}
				
				}
	cout << "dlugosc usuwana "<<nazwa_awarii.size()<<endl;
	zakoncz_awarie_lotniska(wsk->nazwa_obiektu, nazwa_awarii);
	}
	
//===============================================================	
vector<samolot_polozenie> Zdarzenia::samoloty_na_lotnisku()
{
	string airport = airport_from;
	vector<samolot_polozenie>::iterator ptr;
	vector<samolot_polozenie> nowy;
	
	
	for(ptr=akt_pol_samolotow.begin(); ptr!=akt_pol_samolotow.end(); ptr++)
		{cout<<"mamy na lotnisku"<<endl;
			//docelowe jest null po aktualizacji od bryzy
			cout<<airport<<" "<<airport.size()<<endl;
			cout<<ptr->lotnisko_zrodlowe<<" "<<(ptr->lotnisko_zrodlowe).size()<<endl;
			if((ptr->lotnisko_zrodlowe ==airport)&&(ptr->wyladowal==true))
				{
					nowy.push_back(*ptr);
				  cout<<"if"<<endl;
				}
		}
	return nowy;
}

//===============================================================	
vector<lotnisko> Zdarzenia::get_lotniska()							//wysuplanie dostepnych lotnisk
	{

		return lotniska;
	
	}
//===============================================================
	vector<lista_awarii> Zdarzenia::get_lotniska_awarie()			//wysuplanie listy_awarii_na_lotniskach
	{
		return awarie_lotnisk;
	}
//===============================================================	

vector<zdarzenie> Zdarzenia::mozliwe_awarie_lotnisko()
{
		string airport = airport_from;
		vector<zdarzenie>::iterator ptr;
		vector<zdarzenie>::iterator ptr1;
		vector<lista_awarii>::iterator wsk;
		
		vector<zdarzenie> nowy;
	for(wsk=awarie_lotnisk.begin(); wsk!=awarie_lotnisk.end(); wsk++)
		{
		cout<<wsk->nazwa_obiektu<<endl;
		if(wsk->nazwa_obiektu==airport)
		    break;
		}

	if(wsk!=NULL)	
	 if((wsk->awaria).begin()==NULL)
	   cout<<"ddddddddddd"<<endl;	
	
	cout<<"poszlo"<<endl;
		
	if(wsk!=NULL && wsk!=awarie_lotnisk.end() && (wsk->awaria).begin()!=NULL)
		for(ptr1=zdarzenia.begin(); ptr1!=zdarzenia.end(); ptr1++)
		{  
			for(ptr=(wsk->awaria).begin(); ptr!=(wsk->awaria).end(); ptr++)
			{
					if((ptr->nazwa==ptr1->nazwa))
						break;
			}
		
		  	
			if((ptr==(wsk->awaria).end())&&ptr1->typ==2)
			{
					 nowy.push_back(*ptr1);
			}	
		}
		
	else
	{
	     for(ptr1=zdarzenia.begin();ptr1!=zdarzenia.end();ptr1++)
	     {
	      if(ptr1->typ==2)
	         nowy.push_back(*ptr1);
	     }
	}
	cout<<zdarzenia.size()<<endl;    	
	return nowy;	
}

//tosamo bedzie tutej==============================================

vector<zdarzenie> Zdarzenia::mozliwe_awarie_pogody()
{
		string nazwa_lotniska=airport_from;
		vector<zdarzenie>::iterator ptr;
		vector<zdarzenie>::iterator ptr1;
		vector<lista_awarii>::iterator wsk;
		
		vector<zdarzenie> nowy;
		
			
	for(wsk=stan_pogody.begin(); wsk!=stan_pogody.end(); wsk++)
		{
		if(wsk->nazwa_obiektu==nazwa_lotniska)
		    break;
		}
		
	if(wsk!=NULL && wsk!=stan_pogody.end() && (wsk->awaria).begin()!=NULL)
		for(ptr1=zdarzenia.begin(); ptr1!=zdarzenia.end(); ptr1++)
		{  
			for(ptr=(wsk->awaria).begin(); ptr!=(wsk->awaria).end(); ptr++)
			{
					if((ptr->nazwa==ptr1->nazwa))
						break;
			}
		
		  	
			if((ptr==(wsk->awaria).end())&&ptr1->typ==3)
			{
					 nowy.push_back(*ptr1);
			}	
		}
		
	else
	{
	     for(ptr1=zdarzenia.begin();ptr1!=zdarzenia.end();ptr1++)
	     {
	      if(ptr1->typ==3)
	         nowy.push_back(*ptr1);
	     }
	}    	
	return nowy;	

}

//=======================//dziala w pelni========================================
lista_awarii Zdarzenia::get_lotnisko_awarie(const char* nazwa_lotniska)		//wysuplanie listy_awarii_na_danym_lotnisku
	{
		lista_awarii konkretny;
		vector<lista_awarii>::iterator wsk;
		//wyszukanie odpowiednich danych z lotnisk
		for(wsk=awarie_lotnisk.begin(); wsk!=awarie_lotnisk.end(); wsk++)
			{
				if(!strncmp(nazwa_lotniska,(wsk->nazwa_obiektu).c_str(),(wsk->nazwa_obiektu).size()))
					{
					konkretny=(*wsk);
					}
			}
		return konkretny;
	}
//===============================================================
vector<lista_awarii> Zdarzenia::get_lotniska_pogoda()			//wysuplanie listy_pogody_na_lotniskach
	{
	return stan_pogody;
	}
	
//===========================//chyba dziala w pelni================================
lista_awarii Zdarzenia::get_lotnisko_pogoda(const char *nazwa_lotniska)
	{
		//cout << nazwa_lotniska<<endl;
		lista_awarii konkretny;
		vector<lista_awarii>::iterator wsk;
		
		//wyszukanie odpowiednich danych z lotnisk
		for(wsk=stan_pogody.begin(); wsk!=stan_pogody.end(); wsk++)
			{
				if(!strncmp(nazwa_lotniska,(wsk->nazwa_obiektu).c_str(),(wsk->nazwa_obiektu).size()))
					{
					konkretny=(*wsk);
					}
			}
		return konkretny;
	}
//===============================================================

void Zdarzenia::put_airport_from(const char* nazwa_lotniska)
{
	airport_from = nazwa_lotniska;
}
//==============================================================
const char* Zdarzenia::get_airport_from() 
{
	return airport_from;
}
//===============================================================
void Zdarzenia::put_airport_to(const char* nazwa_lotniska)
{
	airport_to = nazwa_lotniska;
}
//===============================================================
const char* Zdarzenia::get_airport_to()
{
	return airport_to;
	
}

//===============================================================
void Zdarzenia::put_airplane(const char* nazwa_samolotu)
{
	airplane = nazwa_samolotu;
}
const char* Zdarzenia::get_airplane()
{
	return airplane;
}
void Zdarzenia::put_weather(const char* nazwa_pogody)
{
	weather = nazwa_pogody;
}
const char* Zdarzenia::get_weather()
{
	return weather;
}
void Zdarzenia::put_event(const char* nazwa_awarii)
{
	airport_event = nazwa_awarii;
}
const char* Zdarzenia::get_event()
{
	return airport_event;
}
void Zdarzenia::put_airplane_event(const char* nazwa_awarii)
{
	airplane_event = nazwa_awarii;
}
const char* Zdarzenia::get_airplane_event()
{
	return airplane_event;
}

vector<zdarzenie> Zdarzenia::get_awarie()
{
	return zdarzenia;
}


void Zdarzenia::put_level(int stopien)
{
	level = stopien;
}
int Zdarzenia::get_level()
{
	return level;
}


void Zdarzenia::put_airplane_id(int id)
{
	airplane_id = id;
}

int Zdarzenia::get_airplane_id()
{
	return airplane_id;
}


